package test;
//单向链表+单链反序
public class LinkedListText {
    //头节点
    private Node headNode;
    //元素个数
    private int size=0;

//---------获取尾部节点
    private Node getLastNode(Node next){

        if(next.next==null){
            return next;
        }
        //在节点.next不为null时
        return getLastNode(next.next);
    }
//---------获取下标节点
    private Node indextNode(int indext){
        Node indextNode = headNode ;

        for(int j =0;j<indext;j++){
            indextNode = indextNode.next;
        }
        return indextNode;
    }

//--------根据下标获取节点
    private Node getIndexNode(int indext){
        //--------元素下标不存在
        if(indext<=0 && indext>this.size){
            throw new IndexCrossTheBorderExcption("异常下标不存在");
        }
        //-------元素下标存在

        return indextNode(indext);

    }
//--------拿到节点从头部插入
    private void headInsert(Node node){
        if(headNode==null){//如果为新链表头节点为null（第一次添加）
            node.next=null;
            headNode=node;
            size++;
            return;
        }
        node.next=headNode;//添加的节点作为头节点
        headNode=node;
        size++;
    }
//--增
    public void add(Object type){
        // LinkedListText head = new LinkedListText();
        //------头节点为null 添加头节点
        if(this.headNode==null){
            size++;
            Node n = new Node(type);
            //  System.out.println(n.key+""+n.index);



            this.headNode=n;
        }
        //---------头节点不为null
        else if(this.headNode!=null){
            //尾部节点

            Node lastNode = getLastNode(headNode);
            //尾部节点添加新的尾部节点
            size++;
            Node addLastNode = new Node(type);
            lastNode.next = addLastNode;

            // System.out.println(addLastNode.key+"---下标为---"+addLastNode.index);


        }




    }
//--查
    public Object get(int indext){
        return getIndexNode(indext).key;
    }
    public int size(){
        return size;
    }
//--删
    public void clear(){
        headNode=null;
        size=0;
    }
    public void remove(Object key){
        Node removeNode=this.headNode;
        //被删除的前一个节点
        Node frontRemoveNode=null;
        //头节点
        Node i =this.headNode;
        //获取要被删除的节点
        while(true){

            if (removeNode.key==key){
                break;
            }
            if(removeNode.next==null){
                return;
            }
            removeNode=removeNode.next;
        }
        //如果删除的节点是头节点 没有前置节点
        if(key==headNode.key){
            headNode=headNode.next;
            size--;
            return;
        }
        //--获取被删除节点的  前置节点
        while (true){
            if(i.next.key==removeNode.key && i.next.key==key){
                frontRemoveNode = i;
                break;
            }
            i=i.next;
        }
        Node removenextNode =removeNode.next;


        frontRemoveNode.next= removenextNode;
        size--;
    }
//--改
//--反向链表
    public void reverse(){
        LinkedListText list=new LinkedListText();//创建一个新的链表集合
        //该链表的头节点和下一个节点
        Node node=headNode;
        Node nodeNext=node.next;

        while(true){
            list.headInsert(node);

            node=nodeNext;
            nodeNext=node.next;

            if(node.next==null){
                list.headInsert(node);
                break;
            }

        }
        this.headNode=list.headNode;
        this.size=list.size;
    }
    //头部插入

//节点内部类-----
    public class Node{
        Object key;
        Node next;

        Node(){
        }
        Node(Object key){
            this.key = key;

        }
    }
}
